Prueba Data Scientist - Rappi

Daniela Carolina Sanabria

25/09/2022

En esta prueba se construyen diferentes modelos de machine learning para predecir el precio de la vivienda con base en características propias y en su ubicación.

#Importación de librerías
import os
import pandas as pd
import numpy as np
from pandas_profiling import ProfileReport
from pyzipcode import ZipCodeDatabase
from uszipcode import SearchEngine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.linear_model import SGDRegressor, LinearRegression
from sklearn.svm import SVR
from sklearn.neural_network import MLPRegressor
from xgboost import XGBRegressor
from lightgbm import LGBMRegressor
from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import mean_squared_error, r2_score, mean_squared_log_error, mean_absolute_error

#Se establece como directorio de ejecición la ubicación local de este Notebook
file_path = os.path.dirname(os.path.abspath("__file__"))
os.chdir(file_path)

#Cargue del archivo
datos_ventas=pd.read_csv("house_sales.csv")

1. Análisis exploratorio

#Dimensiones de los datos
datos_ventas.shape

(18448, 16)

Tenemos 18.448 observaciones y 16 columnas. Los datos están en formatos númerico enteros o flotantes.

#Revisión del tipo de datos de cada columna
datos_ventas.dtypes

price                         int64
num_bed                       int64
num_bath                    float64
size_house                    int64
size_lot                      int64
num_floors                  float64
is_waterfront                 int64
condition                     int64
size_basement                 int64
year_built                    int64
renovation_date               int64
zip                           int64
latitude                    float64
longitude                   float64
avg_size_neighbor_houses      int64
avg_size_neighbor_lot         int64
dtype: object

Aparentemente no hay datos faltantes.

datos_ventas.isna().sum()

price                       0
num_bed                     0
num_bath                    0
size_house                  0
size_lot                    0
num_floors                  0
is_waterfront               0
condition                   0
size_basement               0
year_built                  0
renovation_date             0
zip                         0
latitude                    0
longitude                   0
avg_size_neighbor_houses    0
avg_size_neighbor_lot       0
dtype: int64

La distribución de la mayoría de variables hace sentido, pero se evidencian observaciones en las que el número de habitaciones y el número de baños es de cero. Lo más probable es que esos sean en realidad datos faltantes.

datos_ventas.describe(include=[np.number])

	price	num_bed	num_bath	size_house	size_lot	num_floors	is_waterfront	condition	size_basement	year_built	renovation_date	zip	latitude	longitude	avg_size_neighbor_houses	avg_size_neighbor_lot
count	1.844800e+04	18448.000000	18448.000000	18448.000000	1.844800e+04	18448.000000	18448.000000	18448.000000	18448.000000	18448.000000	18448.000000	18448.000000	18448.000000	18448.000000	18448.000000	18448.000000
mean	5.423624e+05	3.372615	2.118888	2083.940915	1.503602e+04	1.494606	0.007643	3.411698	293.571498	1971.001138	85.145002	98077.921455	47.560030	-122.214419	1988.306483	12571.596216
std	3.720135e+05	0.933892	0.772384	921.416218	4.181455e+04	0.540806	0.087092	0.652593	443.607503	29.361619	403.371263	53.497440	0.138557	0.139910	686.173124	26329.260211
min	7.800000e+04	0.000000	0.000000	290.000000	5.200000e+02	1.000000	0.000000	1.000000	0.000000	1900.000000	0.000000	98001.000000	47.155933	-122.518648	399.000000	651.000000
25%	3.218375e+05	3.000000	1.750000	1430.000000	5.050000e+03	1.000000	0.000000	3.000000	0.000000	1952.000000	0.000000	98033.000000	47.471527	-122.328084	1490.000000	5100.000000
50%	4.500000e+05	3.000000	2.250000	1920.000000	7.600500e+03	1.500000	0.000000	3.000000	0.000000	1975.000000	0.000000	98065.000000	47.571599	-122.230688	1840.000000	7611.000000
75%	6.480000e+05	4.000000	2.500000	2560.000000	1.062525e+04	2.000000	0.000000	4.000000	570.000000	1997.000000	0.000000	98118.000000	47.677918	-122.125733	2370.000000	10050.000000
max	7.700000e+06	33.000000	8.000000	13540.000000	1.651359e+06	3.500000	1.000000	5.000000	4820.000000	2015.000000	2015.000000	98199.000000	47.777624	-121.315254	6110.000000	858132.000000

Teniendo en cuenta las características de las viviendas con cero habitaciones o cero baños según los datos originales, se confirma que son datos faltantes. Por ejemplo, no es probable que una vivienda de 3.5 pisos y 3064 Ft2 (284 M2) no tenga habitaciones ni baños. Teniendo en cuenta que las observaciones con estos datos faltantes son solo 12 en unos datos con 18.448 observaciones, la eliminación de estas no tendrá mayor impacto en el desempeño predictivo de los modelos. Así pues, se toma la decisión de eliminarlas.

datos_ventas.loc[(datos_ventas['num_bed']==0)|(datos_ventas['num_bath']==0), :]

	price	num_bed	num_bath	size_house	size_lot	num_floors	is_waterfront	condition	size_basement	year_built	renovation_date	zip	latitude	longitude	avg_size_neighbor_houses	avg_size_neighbor_lot
744	1095000	0	0.00	3064	4764	3.5	0	3	0	1990	0	98102	47.636246	-122.321563	2360	4000
2641	380000	0	0.00	1470	979	3.0	0	3	0	2006	0	98133	47.714460	-122.356067	1470	1399
2942	288000	0	1.50	1430	1650	3.0	0	3	0	1999	0	98125	47.722172	-122.290286	1430	1650
4160	228000	0	1.00	390	5900	1.0	0	2	0	1953	0	98118	47.526040	-122.261427	2170	6000
5964	1295648	0	0.00	4810	28008	2.0	0	3	0	1990	0	98053	47.664215	-122.069243	4740	35061
7221	339950	0	2.50	2290	8319	2.0	0	3	0	1985	0	98042	47.347267	-122.151189	2500	8751
7228	240000	0	2.50	1810	5669	2.0	0	3	0	2003	0	98038	47.349347	-122.052628	1810	5685
8329	355000	0	0.00	2460	8049	2.0	0	3	0	1990	0	98031	47.409511	-122.168250	2520	8050
8400	235000	0	0.00	1470	4800	2.0	0	3	0	1996	0	98065	47.526491	-121.828222	1060	7200
12266	139950	0	0.00	844	4269	1.0	0	4	0	1913	0	98001	47.278148	-122.249697	1380	9600
15691	265000	0	0.75	384	213444	1.0	0	3	0	2003	0	98070	47.417727	-122.491217	1920	224341
16612	142000	0	0.00	290	20875	1.0	0	1	0	1963	0	98024	47.530772	-121.888423	1620	22850

datos_ventas=datos_ventas.loc[(datos_ventas['num_bed']!=0)&(datos_ventas['num_bath']!=0), :]

#Se utiliza la librería Pandas Profiling para ampliar el EDA
prof = ProfileReport(datos_ventas)
prof

Summarize dataset: 100%|██████████| 255/255 [00:46<00:00,  5.54it/s, Completed]                                                 
Generate report structure: 100%|██████████| 1/1 [00:07<00:00,  7.63s/it]
Render HTML: 100%|██████████| 1/1 [00:08<00:00,  8.50s/it]

Como resultado de este análisis exploratorio, se resalta los siguiente:

• La calidad de los datos parece ser suficiente. Es decir, las variables tienen completitud en la información y sus valores tienen sentido.
• En los datos a predecir tenemos viviendas en un expectro amplio de precios. Hay viviendas de entre 78.000 USD y 7.7 M USD, aunque la vivienda tiene un precio de 450.000 USD y aproximadamente el 90% de las viviendas están por encima de 210.000 USD y por debajo de 1'180.000 USD.
• La gran mayoría de las viviendas tiene 3 o 4 habitaciones, pero también hay viviendas de entre 1 y 2 y de más de 5. En número de baños, por el contrario, existe más heterogeneidad.
• Existen viviendas entre 35 M2 (380ft2) y 1257 M2(13540ft2), con una media de 193 M (2084.2 ft2). La mayoría de viviendas tienen 1 o 2 pisos.
• Unas pocas viviendas en esta base de datos tienen vista al mar (141) y la mayoría de viviendas no tenen sótano.
• La mayoría de las viviendas están en condición media. Unas pocas viviendas presentan mala condición.

• Hay viviendas construidas desde 1900 hasta 2015, pero la mayoría fueron construidas entre 1952 y 1997 (Q1 y Q3). El 95.7% de todas las viviendas no han sido renovadas nunca.

• El precio tiene una mayor correlación con el tamaño de la casa, y como es de esperarse, esto a su vez se relaciona bastante con el número de habitaciones o baños y con el tamaño de las casas y los lotes vecinos.

• La ubicación parece tener relación con el año construido.

Feature Engineering

La ubicación es un elemento clave para predecir el precio de la vivienda. Una vivienda de características muy similares puede tener un precio diferente a otra solo por estar en una ciudad o un estado diferente.

Teniendo en cuenta que el código ZIP no necesariamente es ordinal sino categórica y tiene 70 valores diferentes, se extraerá la ciudad y el estado de la vivienda. Predecir con la ciudad nos permitirá tener menor dimensionalidad en el modelo.

#Extracción del estado y la ciudad
sr = SearchEngine()
datos_ventas['state']=datos_ventas['zip'].apply(lambda x: sr.by_zipcode(x).state)
datos_ventas['city']=datos_ventas['zip'].apply(lambda x: sr.by_zipcode(x).city)

#Observaciones por Estado
datos_ventas['state'].value_counts()

WA    18436
Name: state, dtype: int64

#Observaciones por ciudad
datos_ventas['city'].value_counts()

Seattle          7676
Renton           1343
Bellevue         1203
Kent             1029
Kirkland          846
Redmond           816
Auburn            783
Sammamish         677
Federal Way       670
Issaquah          627
Maple Valley      503
Woodinville       401
Snoqualmie        262
Mercer Island     243
Kenmore           236
Enumclaw          198
North Bend        184
Bothell           178
Duvall            161
Vashon            101
Carnation         100
Black Diamond      84
Fall City          70
Medina             45
Name: city, dtype: int64

Se evidencia que todas las observaciones son del estado de Washington, pertenecientes a 24 ciudades. Las ciudades serán variable categórica en nuestro modelo, y teniendo en cuenta el número de ciudades, se decidirá un método de codificación One Hot Encoding

#Número de nulos en la ciudad
datos_ventas['city'].isna().sum()

0

#Ciudades únicas
len(datos_ventas['city'].unique())

24

#One hot encoding para las ciudades
datos_ventas=pd.get_dummies(datos_ventas,prefix=['city'],columns=['city'])

#Se eligen todas las features para el modelo. Se excluye el Estado (Porque es igual para todas las observaciones) y el código ZIP, que será reemplazado por la ciudad. 
features=[var for var in datos_ventas.columns if var not in (['zip', 'state', 'price'])]
X=datos_ventas.loc[:, features]
y=datos_ventas.loc[:, 'price']

#Se seleccionan las variables que son dummies (las de la ciudad y la que indica que tiene vista al mar)
dummies=features[14:]
dummies.append('is_waterfront')
print(dummies)
#Y así mismo se seleccionan las demás variables
features_to_scale=[var for var in features if var not in (dummies)]
print(features_to_scale)

['city_Auburn', 'city_Bellevue', 'city_Black Diamond', 'city_Bothell', 'city_Carnation', 'city_Duvall', 'city_Enumclaw', 'city_Fall City', 'city_Federal Way', 'city_Issaquah', 'city_Kenmore', 'city_Kent', 'city_Kirkland', 'city_Maple Valley', 'city_Medina', 'city_Mercer Island', 'city_North Bend', 'city_Redmond', 'city_Renton', 'city_Sammamish', 'city_Seattle', 'city_Snoqualmie', 'city_Vashon', 'city_Woodinville', 'is_waterfront']
['num_bed', 'num_bath', 'size_house', 'size_lot', 'num_floors', 'condition', 'size_basement', 'year_built', 'renovation_date', 'latitude', 'longitude', 'avg_size_neighbor_houses', 'avg_size_neighbor_lot']

#Se escalan las varaibles que no son dummies. 
scaler = StandardScaler()
scaler.fit(X[features_to_scale])
X_scaledfeatures=scaler.transform(X[features_to_scale])

#Se concatenan las variables que se escalaron con las demás
X_Processed = np.concatenate([X_scaledfeatures, X[dummies]], axis=1)

Entrenamiento del modelo

Se entrenarán múliples algoritmos y se irán añadiendo los resultados a un DataFrame.

#División de los datos entre train y test
X_train, X_test, y_train, y_test = train_test_split(X_Processed, y, test_size=0.33, random_state=33)

#Functión para evaluar los resultados de cada modelo y añadirlos a un DataFrame para analizar los resultados al final
def evaluacion_modelo(y_test, y_pred, modelo):
    result=dict()
    result['Modelo']=modelo
    result['MSE']=mean_squared_error(y_test, y_pred)
    result['RMSE']=np.sqrt(result['MSE'])
    result['MAE']=mean_absolute_error(y_test, y_pred)
    result['MSLE']=mean_squared_log_error(y_test, y_pred)
    result['R2']=r2_score(y_test, y_pred)
    df = pd.DataFrame()
    df = df.append(result, ignore_index=True)
    return df
    
Resultados=pd.DataFrame(columns=['Modelo', 'MSE', 'RMSE', 'MAE', 'MSLE', 'R2'])

Random Forest

#Se intentarán algunos parámetros del algoritmo seleccionados aleatoriamente y mediante el uso de Cross Validation
RandomForest_GS = RandomizedSearchCV(RandomForestRegressor(random_state=0),
                           {
                              'n_estimators':np.arange(50,500,50),
                              'min_samples_split':np.arange(2,10,2),
                              'max_features':['sqrt', 'log2', None],
                              'min_samples_leaf' : np.arange(1, 10, 5)                            
                            },cv=5, scoring="r2",verbose=2,n_jobs=-1, n_iter=15
                           )

RandomForest_GS.fit(X_train,y_train)

Fitting 5 folds for each of 15 candidates, totalling 75 fits

RandomizedSearchCV(cv=5, estimator=RandomForestRegressor(random_state=0),
                   n_iter=15, n_jobs=-1,
                   param_distributions={'max_features': array([0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55, 0.6 ,
       0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9 , 0.95]),
                                        'min_samples_leaf': array([1, 6]),
                                        'min_samples_split': array([2, 4, 6, 8]),
                                        'n_estimators': array([10, 20, 30, 40, 50, 60, 70, 80, 90])},
                   scoring='r2', verbose=2)

#Los mejores parámetros y el mejor score de Cross Validation
print(RandomForest_GS.best_score_)
print(RandomForest_GS.best_params_)

0.842536978319108
{'n_estimators': 90, 'min_samples_split': 8, 'min_samples_leaf': 1, 'max_features': 0.5500000000000002}

#Se entrena el mejor modelo encontrado
RandomForestReg = RandomForestRegressor(n_estimators=RandomForest_GS.best_params_['n_estimators'], min_samples_split=RandomForest_GS.best_params_['min_samples_split']
, min_samples_leaf=RandomForest_GS.best_params_['min_samples_leaf'], max_features=RandomForest_GS.best_params_['max_features'], random_state=0)
RandomForestReg.fit(X_train, y_train)

RandomForestRegressor(max_features=0.5500000000000002, min_samples_split=8,
                      n_estimators=90, random_state=0)

#Se predice con los datos de prueba
y_pred=RandomForestReg.predict(X_test)

#Se obtienen los resultados del modelo
Resultados=Resultados.append(evaluacion_modelo(y_test, y_pred, 'RandomForest'))
Resultados

	Modelo	MSE	RMSE	MAE	MSLE	R2
0	RandomForest	1.875852e+10	136961.730331	76493.454513	0.036788	0.857724

Support Vector Machines

#Nuevamente, Se intentarán algunos parámetros del algoritmo seleccionados aleatoriamente y mediante el uso de Cross Validation
SVM_GS = RandomizedSearchCV(SVR(),
                           {  'kernel':['linear', 'poly', 'rbf', 'sigmoid']
                            },cv=5, scoring="r2",verbose=3,n_jobs=-1, n_iter=10
                           )

SVM_GS.fit(X_train,y_train)

c:\ProgramData\Anaconda3\lib\site-packages\sklearn\model_selection\_search.py:285: UserWarning: The total space of parameters 4 is smaller than n_iter=10. Running 4 iterations. For exhaustive searches, use GridSearchCV.
  warnings.warn(

Fitting 5 folds for each of 4 candidates, totalling 20 fits

RandomizedSearchCV(cv=5, estimator=SVR(), n_jobs=-1,
                   param_distributions={'kernel': ['linear', 'poly', 'rbf',
                                                   'sigmoid']},
                   scoring='r2', verbose=3)

#Los mejores parámetros y el mejor score de Cross Validation
print(SVM_GS.best_score_)
print(SVM_GS.best_params_)

0.003161902835739361
{'kernel': 'linear'}

#Se entrena el modelo con los mejores parámetros encontrados
SVReg = SVR(kernel=SVM_GS.best_params_['kernel'])
SVReg.fit(X_train, y_train)
y_pred_2=SVReg.predict(X_test)

#Se obtienen los resultados del modelo
Resultados=Resultados.append(evaluacion_modelo(y_test, y_pred_2, 'SVM'))
Resultados

	Modelo	MSE	RMSE	MAE	MSLE	R2
0	RandomForest	1.875852e+10	136961.730331	76493.454513	0.036788	0.857724
0	SVM	1.295079e+11	359872.113314	208336.035924	0.239878	0.017735

XGBoost

#Nuevamente, Se intentarán algunos parámetros del algoritmo seleccionados aleatoriamente y mediante el uso de Cross Validation
XGB_GS = RandomizedSearchCV(XGBRegressor(),
                           {  'n_estimators':np.arange(10,100,10),
                              'max_depth':np.arange(2,10,2),
                            },cv=5, scoring="r2",verbose=3,n_jobs=-1, n_iter=10
                           )

XGB_GS.fit(X_train,y_train)

Fitting 5 folds for each of 10 candidates, totalling 50 fits

RandomizedSearchCV(cv=5,
                   estimator=XGBRegressor(base_score=None, booster=None,
                                          callbacks=None,
                                          colsample_bylevel=None,
                                          colsample_bynode=None,
                                          colsample_bytree=None,
                                          early_stopping_rounds=None,
                                          enable_categorical=False,
                                          eval_metric=None, gamma=None,
                                          gpu_id=None, grow_policy=None,
                                          importance_type=None,
                                          interaction_constraints=None,
                                          learning_rate=None, max_bin=None,
                                          m...
                                          max_delta_step=None, max_depth=None,
                                          max_leaves=None,
                                          min_child_weight=None, missing=nan,
                                          monotone_constraints=None,
                                          n_estimators=100, n_jobs=None,
                                          num_parallel_tree=None,
                                          predictor=None, random_state=None,
                                          reg_alpha=None, reg_lambda=None, ...),
                   n_jobs=-1,
                   param_distributions={'max_depth': array([2, 4, 6, 8]),
                                        'n_estimators': array([10, 20, 30, 40, 50, 60, 70, 80, 90])},
                   scoring='r2', verbose=3)

#Los mejores parámetros y el mejor score de Cross Validation
print(XGB_GS.best_score_)
print(XGB_GS.best_params_)

0.8533729489649309
{'n_estimators': 60, 'max_depth': 4}

#Se entrena el modelo con los mejores parámetros encontrados
XGB_Reg = XGBRegressor(n_estimators=XGB_GS.best_params_['n_estimators'], max_depth=XGB_GS.best_params_['max_depth'])
XGB_Reg.fit(X_train, y_train)
y_pred_3=XGB_Reg.predict(X_test)

#Se obtienen los resultados del modelo
Resultados=Resultados.append(evaluacion_modelo(y_test, y_pred_3, 'XGB'))
Resultados

	Modelo	MSE	RMSE	MAE	MSLE	R2
0	RandomForest	1.875852e+10	136961.730331	76493.454513	0.036788	0.857724
0	SVM	1.295079e+11	359872.113314	208336.035924	0.239878	0.017735
0	XGB	1.745310e+10	132110.166185	78125.584968	0.038220	0.867625

LightGBM

#De nuevo, Se intentarán algunos parámetros del algoritmo seleccionados aleatoriamente y mediante el uso de Cross Validation
LGBM_GS = RandomizedSearchCV(LGBMRegressor(),
                           { 'boosting_type': ['gbdt', 'dart' , 'goss'],
                             'num_leaves':np.arange(10,100,10),
                              'max_depth':np.arange(-1,10,1),
                              'learning_rate': np.arange(0.05,1,0.05),
                              'n_estimators':np.arange(50,500,50)
                            },cv=5, scoring="r2",verbose=3,n_jobs=-1, n_iter=10
                           )

LGBM_GS.fit(X_train,y_train)

Fitting 5 folds for each of 10 candidates, totalling 50 fits

RandomizedSearchCV(cv=5, estimator=LGBMRegressor(), n_jobs=-1,
                   param_distributions={'boosting_type': ['gbdt', 'dart',
                                                          'goss'],
                                        'learning_rate': array([0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55,
       0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9 , 0.95]),
                                        'max_depth': array([-1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9]),
                                        'n_estimators': array([ 50, 100, 150, 200, 250, 300, 350, 400, 450]),
                                        'num_leaves': array([10, 20, 30, 40, 50, 60, 70, 80, 90])},
                   scoring='r2', verbose=3)

#Los mejores parámetros y el mejor score de Cross Validation
print(LGBM_GS.best_score_)
print(LGBM_GS.best_params_)

0.855924695802592
{'num_leaves': 80, 'n_estimators': 350, 'max_depth': 4, 'learning_rate': 0.45, 'boosting_type': 'dart'}

#Se entrena el modelo con los mejores parámetros encontrados
LGBM_Reg = LGBMRegressor(boosting_type=LGBM_GS.best_params_['boosting_type'], n_estimators=LGBM_GS.best_params_['n_estimators'],
                        max_depth=LGBM_GS.best_params_['max_depth'],learning_rate=LGBM_GS.best_params_['learning_rate'])
LGBM_Reg.fit(X_train, y_train)
y_pred_4=LGBM_Reg.predict(X_test)

#Se obtienen los resultados del modelo
Resultados=Resultados.append(evaluacion_modelo(y_test, y_pred_4, 'LGBM'))
Resultados

	Modelo	MSE	RMSE	MAE	MSLE	R2
0	RandomForest	1.875852e+10	136961.730331	76493.454513	0.036788	0.857724
0	SVM	1.295079e+11	359872.113314	208336.035924	0.239878	0.017735
0	XGB	1.745310e+10	132110.166185	78125.584968	0.038220	0.867625
0	LGBM	1.501293e+10	122527.272719	70990.092131	0.034020	0.886133

ADA Boost

#De nuevo, Se intentarán algunos parámetros del algoritmo seleccionados aleatoriamente y mediante el uso de Cross Validation
ADA_GS = RandomizedSearchCV(AdaBoostRegressor(),
                           { 'loss': ['linear', 'square', 'exponential'],
                              'learning_rate': np.arange(0.05,1,0.05),
                              'n_estimators':np.arange(50,500,50)
                            },cv=5, scoring="r2",verbose=3,n_jobs=-1, n_iter=10
                           )

ADA_GS.fit(X_train,y_train)

Fitting 5 folds for each of 10 candidates, totalling 50 fits

RandomizedSearchCV(cv=5, estimator=AdaBoostRegressor(), n_jobs=-1,
                   param_distributions={'learning_rate': array([0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55,
       0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9 , 0.95]),
                                        'loss': ['linear', 'square',
                                                 'exponential'],
                                        'n_estimators': array([ 50, 100, 150, 200, 250, 300, 350, 400, 450])},
                   scoring='r2', verbose=3)

#Los mejores parámetros y el mejor score de Cross Validation
print(ADA_GS.best_score_)
print(ADA_GS.best_params_)

0.6084640022249133
{'n_estimators': 50, 'loss': 'exponential', 'learning_rate': 0.3}

#Se entrena el modelo con los mejores parámetros encontrados
ADAb_Reg = AdaBoostRegressor(loss=ADA_GS.best_params_['loss'], n_estimators=ADA_GS.best_params_['n_estimators'], learning_rate=ADA_GS.best_params_['learning_rate'])
ADAb_Reg.fit(X_train, y_train)
y_pred_5=ADAb_Reg.predict(X_test)

#Se obtienen los resultados del modelo
Resultados=Resultados.append(evaluacion_modelo(y_test, y_pred_5, 'AdaBoost'))
Resultados

	Modelo	MSE	RMSE	MAE	MSLE	R2
0	RandomForest	1.875852e+10	136961.730331	76493.454513	0.036788	0.857724
0	SVM	1.295079e+11	359872.113314	208336.035924	0.239878	0.017735
0	XGB	1.745310e+10	132110.166185	78125.584968	0.038220	0.867625
0	LGBM	1.501293e+10	122527.272719	70990.092131	0.034020	0.886133
0	AdaBoost	5.873868e+10	242360.649207	180920.239607	0.173534	0.554491

KNeighborsRegressor

#Se entrena el modelo con los parámetros por defecto
KNR_Reg = KNeighborsRegressor()
KNR_Reg.fit(X_train, y_train)
y_pred_6=KNR_Reg.predict(X_test)

#Se obtienen los resultados del modelo
Resultados=Resultados.append(evaluacion_modelo(y_test, y_pred_5, 'KNeighbors'))
Resultados

	Modelo	MSE	RMSE	MAE	MSLE	R2
0	RandomForest	1.875852e+10	136961.730331	76493.454513	0.036788	0.857724
0	SVM	1.295079e+11	359872.113314	208336.035924	0.239878	0.017735
0	XGB	1.745310e+10	132110.166185	78125.584968	0.038220	0.867625
0	LGBM	1.501293e+10	122527.272719	70990.092131	0.034020	0.886133
0	AdaBoost	5.873868e+10	242360.649207	180920.239607	0.173534	0.554491
0	KNeighbors	5.873868e+10	242360.649207	180920.239607	0.173534	0.554491

Multilayer Perceptron

from sklearn.neural_network import MLPRegressor

#De nuevo, Se intentarán algunos parámetros del algoritmo seleccionados aleatoriamente y mediante el uso de Cross Validation
NN_GS = RandomizedSearchCV(MLPRegressor(),
                           { 'activation': ['identity', 'logistic', 'tanh' , 'relu'],
                           'solver':['lbfgs', 'sgd', 'adam'],
                           'learning_rate': ['constant', 'invscaling', 'adaptive'],
                              'alpha': [0.0001, 0.001, 0.01]
                            },cv=5, scoring="r2",verbose=3,n_jobs=-1, n_iter=10
                           )

NN_GS.fit(X_train,y_train)

Fitting 5 folds for each of 10 candidates, totalling 50 fits

c:\ProgramData\Anaconda3\lib\site-packages\sklearn\model_selection\_search.py:918: UserWarning: One or more of the test scores are non-finite: [ 0.6610277   0.51501007  0.86859479 -2.10225394  0.66085019 -2.10225647
 -1.72876628  0.52190091 -2.10207141         nan]
  warnings.warn(
c:\ProgramData\Anaconda3\lib\site-packages\sklearn\neural_network\_multilayer_perceptron.py:500: ConvergenceWarning: lbfgs failed to converge (status=1):
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
    https://scikit-learn.org/stable/modules/preprocessing.html
  self.n_iter_ = _check_optimize_result("lbfgs", opt_res, self.max_iter)

RandomizedSearchCV(cv=5, estimator=MLPRegressor(), n_jobs=-1,
                   param_distributions={'activation': ['identity', 'logistic',
                                                       'tanh', 'relu'],
                                        'alpha': [0.0001, 0.001, 0.01],
                                        'learning_rate': ['constant',
                                                          'invscaling',
                                                          'adaptive'],
                                        'solver': ['lbfgs', 'sgd', 'adam']},
                   scoring='r2', verbose=3)

#Los mejores parámetros y el mejor score de Cross Validation
print(NN_GS.best_score_)
print(NN_GS.best_params_)

0.8685947913436127
{'solver': 'lbfgs', 'learning_rate': 'adaptive', 'alpha': 0.0001, 'activation': 'relu'}

#Se entrena el modelo con los mejores parámetros encontrados
MLP_Reg = MLPRegressor(activation=NN_GS.best_params_['activation'], solver=NN_GS.best_params_['solver'], 
learning_rate=NN_GS.best_params_['learning_rate'], alpha=NN_GS.best_params_['alpha'])
MLP_Reg.fit(X_train, y_train)
y_pred_6=MLP_Reg.predict(X_test)

c:\ProgramData\Anaconda3\lib\site-packages\sklearn\neural_network\_multilayer_perceptron.py:500: ConvergenceWarning: lbfgs failed to converge (status=1):
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
    https://scikit-learn.org/stable/modules/preprocessing.html
  self.n_iter_ = _check_optimize_result("lbfgs", opt_res, self.max_iter)

#Se obtienen los resultados del modelo
Resultados=Resultados.append(evaluacion_modelo(y_test, y_pred_6, 'MultiLayer Perceptron'))
Resultados

	Modelo	MSE	RMSE	MAE	MSLE	R2
0	RandomForest	1.875852e+10	136961.730331	76493.454513	0.036788	0.857724
0	SVM	1.295079e+11	359872.113314	208336.035924	0.239878	0.017735
0	XGB	1.745310e+10	132110.166185	78125.584968	0.038220	0.867625
0	LGBM	1.501293e+10	122527.272719	70990.092131	0.034020	0.886133
0	AdaBoost	5.873868e+10	242360.649207	180920.239607	0.173534	0.554491
0	KNeighbors	5.873868e+10	242360.649207	180920.239607	0.173534	0.554491
0	MultiLayer Perceptron	2.133273e+10	146057.276150	81453.232378	0.042390	0.838200

Conclusión del ejercicio

El mejor resultado fue el del modelo LightGBM, con un R2 de 89% y un RMSE de 122.527 USD. Para otros ejercicios, los resultados podrían mejorarse haciendo más iteraciones de los hiperparámetros de todos los modelos. El peor resultado fue el del Support Vector Machines, lo cual puede explicarse por el número de features que se incluyen en este modelo y porque no se incluyeron otros parámetros en la grilla.